程序员练级攻略：Java底层知识-[2026重制版]

// 源代码
public class HelloWorld {
    public static int add(int a, int b) {
        return a + b;
    }
}

public static int add(int, int);
  Code:
   stack=2, locals=2, args_size=2
    0: iload_0       // 将第一个int参数压栈
    1: iload_1       // 将第二个int参数压栈
    2: iadd          // 栈顶两个int相加
    3: ireturn       // 返回int结果

import net.bytebuddy.ByteBuddy;
import net.bytebuddy.dynamic.DynamicType;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.matcher.ElementMatchers;

// 示例1：动态创建类
DynamicType.Unloaded<?> dynamicType = new ByteBuddy()
    .subclass(Object.class)
    .name("com.example.HelloWorld")
    .defineMethod("sayHello")
    .returns(String.class)
    .annotateMethod(AnnotationDescription.Builder.ofType(Deprecated.class).build())
    .intercept(MethodDelegation.to(HelloWorld.class))
    .make();

// 示例2：方法拦截（AOP）
class TimingInterceptor {
    @RuntimeType
    public static Object intercept(@Origin Method method,
                                   @SuperCall Callable<?> callable) throws Exception {
        long start = System.nanoTime();
        try {
            return callable.call();  // 调用原方法
        } finally {
            long duration = System.nanoTime() - start;
            System.out.printf("%s took %d ns%n", method.getName(), duration);
        }
    }
}

// 应用拦截器
new ByteBuddy()
    .subclass(TargetClass.class)
    .method(ElementMatchers.named("importantMethod"))
    .intercept(MethodDelegation.to(TimingInterceptor.class))
    .make()
    .load(ClassLoader.getSystemClassLoader())
    .getLoaded();

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;

public class MyAgent {

    // 启动时执行（-javaagent选项）
    public static void premain(String agentArgs, Instrumentation inst) {
        System.out.println("[Agent] JVM starting with args: " + agentArgs);

        // 注册类文件转换器
        inst.addTransformer(new MyClassTransformer());
    }

    // 运行时附加执行
    public static void agentmain(String agentArgs, Instrumentation inst) {
        System.out.println("[Agent] Attached to running JVM");
        inst.addTransformer(new MyClassTransformer());

        // 重定义已加载的类
        inst.retransformClasses(MyTargetClass.class);
    }
}

// 类转换器：在类加载时修改字节码
class MyClassTransformer implements ClassFileTransformer {
    @Override
    public byte[] transform(ClassLoader loader, String className,
                           Class<?> classBeingRedefined,
                           ProtectionDomain protectionDomain,
                           byte[] classfileBuffer) {
        if (!"com/example/MyTargetClass".equals(className)) {
            return null;  // 不处理其他类
        }

        System.out.println("[Agent] Transforming: " + className);

        // 使用ASM或Byte Buddy修改字节码
        return transformWithByteBuddy(classfileBuffer);
    }
}

Manifest-Version: 1.0
Premain-Class: com.example.MyAgent
Agent-Class: com.example.MyAgent
Can-Redefine-Classes: true
Can-Retransform-Classes: true
Boot-Class-Path: byte-buddy-1.14.10.jar

# 方式1：启动时加载
java -javaagent:path/to/agent.jar -jar myapp.jar

# 方式2：运行时附加（需要tools.jar）
java -cp tools.jar com.sun.tools.attach.VirtualMachine <pid> path/to/agent.jar

// 简化的ClassLoader加载流程
protected Class<?> loadClass(String name, boolean resolve) {
    // 1. 检查是否已加载
    Class<?> c = findLoadedClass(name);

    if (c == null) {
        try {
            if (parent != null) {
                c = parent.loadClass(name, false);  // 委派给父加载器
            } else {
                c = findBootstrapClassOrNull(name);  // 启动类加载器
            }
        } catch (ClassNotFoundException e) {
            // 父加载器无法完成，自己尝试加载
            c = findClass(name);
        }
    }

    if (resolve) {
        resolveClass(c);
    }
    return c;
}

# 推荐：G1 GC配置（通用场景）
java -XX:+UseG1GC \
     -Xmx4g -Xms4g \                    # 固定堆大小
     -XX:MaxGCPauseMillis=200 \          # 目标停顿200ms
     -XX:G1HeapRegionSize=16m \          # Region大小
     -XX:+G1UseAdaptiveIHOP \           # 自适应IHOP
     -XX:InitiatingHeapOccupancyPercent=45 \
     -jar app.jar

# 推荐：ZGC配置（低延迟场景）
java -XX:+UseZGC \
     -Xmx16g -Xms16g \
     -XX:ConcGCThreads=2 \               # 并发GC线程数
     -XX:+ZGenerational \                 # JDK 21+ 分代ZGC
     -jar app.jar

// 传统平台线程（昂贵）
ExecutorService executor = Executors.newFixedThreadPool(200);
executor.submit(() -> {
    // 阻塞操作会占用一个真正的OS线程
    Thread.sleep(1000);
});

// 虚拟线程（廉价！）
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 1_000_000; i++) {  // 创建百万个虚拟线程没问题！
        executor.submit(() -> {
            // 阻塞操作只挂起虚拟线程，不占用OS线程
            HttpClient client = HttpClient.newHttpClient();
            HttpResponse<String> response = client.send(
                HttpRequest.newBuilder(URI.create("https://example.com"))
                      .GET().build(),
                HttpResponse.BodyHandlers.ofString()
            );
            return response.body();
        });
    }
}
// 虚拟线程 vs 平台线程对比
// - 创建成本：~1KB vs ~1MB
// - 可创建数量：数百万 vs 数千
// - 调度方式：JVM调度器(M:N) vs OS调度器(1:1)

// 传统写法
public final class Person {
    private final String name;
    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() { return name; }
    public int getAge() { return age; }
    @Override
    public boolean equals(Object o) { ... }
    @Override
    public int hashCode() { ... }
    @Override
    public String toString() { ... }
}

// Record 写法（自动生成上述所有方法）
public record Person(String name, int age) {}

// 使用
Person p = new Person("张三", 25);
System.out.println(p.name());      // 自动生成的getter
System.out.println(p.toString());   // Person[name=张三, age=25]

// Record + Pattern Matching (JDK 21)
if (obj instanceof Person(String name, int age)) {
    System.out.printf("%s is %d years old%n", name, age);
}

// switch 表达式 + 模式匹配
static String formatter(Object obj) {
    return switch (obj) {
        case Integer i -> String.format("int %d", i);
        case Long l    -> String.format("long %d", l);
        case Double d  -> String.format("double %f", d);
        case String s  -> String.format("String %s", s);
        case null      -> "null";
        default        -> obj.toString();
    };
}

// record 解构模式
record Point(int x, int y) {}
void printSum(Object obj) {
    if (obj instanceof Point(var x, var y)) {
        System.out.println(x + y);  // 直接解构
    }
}

// 定义允许哪些子类继承
public sealed interface Shape
    permits Circle, Rectangle, Triangle { }

// 必须是final, sealed, 或 non-sealed
public final class Circle implements Shape {
    private final double radius;
    // ...
}

public non-sealed class Rectangle implements Shape {
    // 允许进一步扩展
}

# 启动JFR记录
java -XX:StartFlightRecording=duration=60s,filename=recording.jfr,filename=app.jfr \
     -jar app.jar

# 运行时启动（JDK 9+）
jcmd <pid> JFR.start duration=60s filename=app.jfr

# 分析记录
jfr print --events GC,JVM_CPU,CPU_Load app.jfr > report.txt